package com.flannery.learningandroid.data.kotlin

fun main(args: Array<String>) {

}

fun test() {
    val site = object {
        var name: String = "name"
        var url: String = "www..."
    }
    println(site.name)
    println(site.url)
}

//主构造器
class ClassDemo2 constructor(firstName: String) {
    init {
        println("FirstName is $firstName")
    }
}

open class Base {
    open fun f() {}
}

//嵌套类
class Outer {
    private val bar: Int = 1

    class Nested {
        fun foo() = 2
    }

    fun test() {
        val demo = Outer.Nested().foo()
        println(demo)
    }
}

//内部类
class Outer2 {
    private val bar: Int = 1
    var v = "成员属性"

    /**嵌套内部类**/
    inner class Inner {
        fun foo() = bar //访问外部类成员
        fun innerTest() {
            var o = this@Outer2 //获取外部类的成员变量
        }
    }

    fun test() {
        val demo = Outer2().Inner().foo()
        println(demo)
        val demo2 = Outer2().Inner().innerTest()
        println(demo2) //内部类可以引用外部类的成员，例如：成员属性
    }
}

//匿名内部类
class Test {
    var v = "成员属性"
    fun setInterFace(test: TestInterFace) {
        test.test()
    }


    fun testMy() {
        var test = Test()
        /**
         * 采用对象表达式来创建接口对象，即匿名内部类的实例
         */
        test.setInterFace(object : TestInterFace {
            override fun test() {
                println("对象表达式创建匿名内部类的实例")
            }

        })
    }
}

/**定义接口**/
interface TestInterFace {
    fun test()
}

//类的修饰符
/**
 * classModifier:类属性的修饰符，表示类本身特性
 * abstract  //抽象类
 * final     //类不可继承，默认属性
 * enum      //枚举类
 * open      //类可继承，类默认是final的
 * annotation //注解类
 *
 * accessModifier：访问权限修饰符
 * private       //仅在同一个文件中可见
 * protected     //同一个文件中或子类可见
 * public        //所有调用的地方都可见
 * internal      //同一个模块中可见
 *
 *
 * 嵌套类和内部类在使用时的区别
 * (1)创建对象的区别
 * var deom = Outter.Nested();//嵌套类，Outter后边没有括号
 * var demo = Outter().Inner();//内部类，Outter后边没有括号
 *
 *
 *
 *
 * (2)引用外部类的成员变量的方式不同
 * 嵌套类
 * class Outer{
 *  private val bar:Int = 1
 *  class Nested{
 *      var ot:Outer = Outer()
 *      println(ot.bar)//嵌套类可以引用外部类私有变量，不能直接引用
 *      fun foo{} = 2
 *  }
 * }
 *
 * 内部类
 * class Outer{
 *  private val bar:Int = 1
 *  var v = "成员属性"
 *  /**嵌套内部类**/
 *  inner class Inner {
 *      fun foo() = bar //访问外部类成员
 *      fun innerTest() {
 *          var o = this@Outer //获取外部类的成员变量
 *          println("内部类可以引用外部类的成员，例如："+o.v)
 *      }
 *  }
 * }
 *
 *
 * 匿名内部类的实现
 * fun main() {
 *  var test = Test()
 *
 *  /*采用对象表达式来创建接口对象，即匿名内部类的实例*/
 *  test.setInterFace(object:TestInterFace{
 *      override fun test() {
 *          println("对象表达式创建匿名内部类的实例")
 *      }
 *  })
 * }
 */

abstract class CCCC {

}

class ClassDemo {
    var name: String = "name"
    var url: String = "url"
    var city: String = "city"


    var lastName: String = ""
        get() = field
        set

    var no: Int = 100
        get() = field
        set(value) {
            if (value < 10) {
                field = value
            } else {
                field = -1
            }
        }


    val instance = ClassDemo("")

    init {
        println("默认构造函数")
    }

    constructor(name: String) {
        println("次级构造函数")
    }


    fun testMy() {
        var c = ClassDemo("name")
        c.lastName = "zhao"
        println("lastName:${c.lastName}")

        c.no = 9
        println("no:${c.no}")

        c.no = 20
        println("no:${c.no}")
    }
}